Cream of the Crop 1/Cream of the Crop 1.iso/SOUND/BASSV25.ARJ/BASS.DOC

Text File | 1992-04-15 | 24KB | 569 lines

Package:
========
      BASS version 2.5 Copyright (c) Andrew Kay, April 1992

     (*for changes since previous version, see end of document*)

What it does:
=============
BASS is a program to produce a bass line, percussion and chords
against which you  can jam. There are several uses for this kind of
thing, for example,
    @ type in a chord sequence to practise improvising with
        (a rhythm section which doesn't get bored)
    @ try out your song ideas, quickly
    @ listen to chord changes which you can't play yourself
    @ home Karaoke player !
    @ produce midi files to import into your sequencer

Requirements:
=============
BASS requires
    @ a PC compatible computer (there may be timing problems on
     older, slower machines).
    @ an MPU 401 compatible MIDI interface card at the standard port
     addresses (The IRQ number can be reconfigured if necessary)
    @ a MIDI synthesiser to hook it up to.
Note that if you use BASS to produce midifiles, then you only need
a PC compatible, without an MPU.

In addition, you need a text editor to enter the sequences. I didn't
include one in the program because I knew you already had an editor,
and didn't want to learn a new one.

Contents:
=========
    bass.exe     -- executable
    bass.doc     -- documentation
    bass.rc      -- sample startup file
    *.bss     -- sample sequences

The package is distributed in archived form. Please redistribute in
this form.

Author:
=======
    Andrew Kay (email to [e-mail] for the moment)

Shareware:
==========
This product must not be sold or resold for profit, other than the
registration fee due to the author. The author retains copyright on
all copies of all versions. The package may be freely distributed, so
long as it remains unmodified and intact, and that the copyright and
shareware notice remains unaltered. The author makes no claims about
the suitability of this software for any particular machine or
purpose. Use it at your own risk.

If you like this product, please show your appreciation by sending 10
pounds sterling (or more!) with your name, address, (email address),
preferred disk format, stating where you found your copy of BASS,
and which version you have, to

    Andrew Kay
    17 Kenton Park Avenue,
    Kenton, Harrow, HA3 8DU
    United Kingdom

Acknowledgment:
===============
The code was written using Borland's Turbo C 2.0 and Turbo Debugger
(copyright (C) Borland) with reference to the Voyetra OP-4000/1
technical reference manual. I would like to thank Dave Favis-Mortlock
(of Jupiter Computer Consultants) for encouragement and numerous
suggestions.

                             ===========
                             QUICK START
                             ===========

First unpack all the files in the archive. I have assumed that your
MPU interface is set to IRQ 2. If not, use a text editor to set the
IRQ number in the file bass.rc (following the \irq line). See the
section on \irq below if you need more help on this. If you get the
wrong IRQ number you will hear either nothing or random noises.

Make sure your synthesiser is switched on and set to recieve midi
data. select a bass sound on channel 1 and a honky tonk piano on
channel 2. From the directory with BASS in it type

                            bass stlouis

Within a few seconds you should see the chords and hear the rhythm
section for this jolly number. Percussion sounds require a little more
preparation (since I don't know exactly how your synthesiser maps
percussion sounds to note numbers. BASS _can_ do percussion ! See the
section on \setperc below)

If you see and hear nothing, then you may need to reconfigure the IRQ,
or perhaps your card is incompatible or in a strange state. If the
last of these is the case then you will need to power down and reboot
the system. If you see the chords but hear nothing, then the problem
is most likely between the MPU and your ears, a path which includes
the MIDI OUT cable, the synth (check the channels and that MIDI is
being received) and the amplifier.

======
Usage:
======
    BASS [-s] [-n] [-c] [-h<hum>] [-f<midifile>]
            [-q<cuetime>] [<filename>]

BASS takes commands from the file bass.rc in the current directory,
if one exists, and then from the file specified by <filename>. If the
file is not found, <filename>.bss is tried instead. The commands are
used to produce `live' music via the MPU MIDI interface, or a standard
MIDI file (type 0) with the -f option.

  -s    read input from standard input, rather than filename

  -n    don't read the bass.rc file

  -c    print out a list (on standard output) of all the chord types
     recognised by BASS, and then terminate. Each chord type is shown
     as it would appear in the key of C, together with the list of
     actual notes it would contain in that key. If you have defined
     new chords (using \chord, see below), they will appear in the
     table.

  -h<hum>
    This option is the `humaniser' -- it allows a certain random
     element to be brought into the performance, both in volume and
     timing. hum is an integer from 0 (no effect) to 10 (maximum
     effect). The default is 0.

   -f<midifile>
    With this option BASS writes a MIDI format 0 file. Note that
     there is no space between the -f and the file name. You must
     include the file extension (usually .mid) if required.

  -q<cuetime>
    This option controls the printing of lyrics and chord names.
     Cuetime can be from 0 to 4, and represents the number of beats
     in advance when the lyric or chord is printed. For a cuetime of
     0 (the default), the playing and printing is (almost) simul-
     taneous. If you want to use the screen as a cue, it can be
     helpful to know in advance which chords and lyrics are coming up.

=========
Controls:
=========
You can make the music faster or slower with the up and down arrow
keys. The brackets [ and ] make the music less or more `swingy' (see
\swing, below). ESC (or space) to stop. Question mark (?) prints
current tempo and swing settings. Any other non-function key prints
a brief help list.

========
Details:
========
Commands are stored in the file bass.rc, and in the file specified on
the command line. They should be created with the text editor of your
choice, and stored in ASCII format. Commands in the specified file
override commands in the bass.rc file.

There are several different commands, all starting with '\'. There
must be a single \seq command, containing the chords of the song.
Comments can be enclosed in braces { voila }, and can be made visible
on standard output by putting an asterisk immediately after the open
brace {*encore}. This is useful for documenting sequences as they
compile, for example, to introduce the song title and key. This
feature should not be confused with the lyric facility, which prints
lyrics as the chords play (see the "specifying a chord sequence --
basics" section).

\irq <n>
========
Sets the irq number for the MPU (<n> should be a number between 0 and 7).
The default is 2. If this is set wrongly, odd things may happen. Unless
you know your card is set differently, leave it at 2.

\tempo <t>
==========
Sets tempo to <t> beats per minute. Range is 16...240

\setbass <c> <t> <v> <p>
========================
Sets bass line to midi channel <c>, transposed <t> semitones, velocity
(volume) <v> and midi program number <p>. Defaults are 1, 0, 120, *.
(an asterisk * can be used to select the default value for any field,
or for <p> an entry of * causes no midi program change to be sent).
The ranges are c (1..16), t (-48..48), v (0..127), p (0..127).

\setchords <c> <t> <v> <p>
==========================
The same as \setbass, but functions for the chord section. Defaults
are 2, 0, 100, *.

\setperc <name> <c> <n> <v>
===========================
This command is used to define a named percussion instrument. The name
is a single letter from a to z. The defined instrument is played on
channel <c> with note number <n> and velocity <v>. If v is zero the
instrument makes no sound. Instruments sound when they are called from
a pattern. In the patterns in bass.rc I have assumed that "b" is the
bass drum, "s" is a snare and "h" a high hat cymbal. For this to work
on my Roland D-110 I set it to recieve percussion on channel 9, and
make the following definitions in the "bass.rc" file.
    \setperc b 9 35 120 {bass drum, chan 9, note 35, velocity 120}
    \setperc s 9 38 120 {snare, chan 9, note 38, velocity 120}
    \setperc h 9 42 100 {high hat, chan 9, note 42, velocity 100}
Your synthesiser is most likely different from this. Consult the
manual to find out which sounds are assigned to which note numbers.

\swing <p> <t>
==============
Sets the percentage swing and swing timescale. If t=60 then swing acts
on pairs of quavers (eighth notes), t=120 acts on pairs of crotchets
(quarter notes). A swing of 50% gives a straight beat, 66% gives a
triplet feel, 33% gives a `snap' feel. In general for a pair of notes
of length t ticks, the first takes p% of the total time, and the
second takes (100-p)% of the time. Defaults are p=50, t=120. The
percentage p% can be adjusted during play with the [ and ] keys (but
some notes may be lost).

\seq <sequence>
===============
Define the sequence of chords in the song. The sequence consists of
a list of chords, with information about which patterns to use (see
below), and how long the chords last. The sequence plays until it runs
out of chords, or interrupted by a keypress. More information on how
to specify the sequence is given below.

\pat <n> <d> <definition>
=========================
Define pattern number <n> of duration <d> (cycle time). n ranges from
0 to 50. A pattern is a series of notes based on the current chord in
a chord sequence. When the sequence is playing, the selected pattern
cycles repeatedly until a new pattern is selected. New chords can
begin part way through a pattern. More information on specifying
patterns is given below.



=====================================
Specifying a Chord Sequence -- Basics
=====================================
A chord sequence is just a list of chord symbols. In addition, you can
set the time for which a chord plays, the pattern number it uses,
section repeats and lyrics (or cues) which print as the sequence
plays.

Normal chords are specified like this:

    A Bm CM7 C#o Eb7 FmM7 G+ Am6 B79 C9 ...

which represent A major, B minor, C with maj7, C sharp diminished, E
flat major with minor 7, F minor with maj7, G aug, A minor 6, B with
minor 7th and 9th, C with 9th. The complete list of accpetable chords
may be obtained by typing "BASS -c" (from the DOS prompt) or
"BASS -c > chords" to store them in the file "chords". The list may
change between versions. Tonic names should be in capitals (or else
`b' might be mistaken for a flat) but need not be if you put spaces
in appropriate places (ie between chords).

A chord which is just a repetition of the previous chord can be
written as `/'. Note that you must leave space between it and the
previous chord so that it is not confused as a bass note specifier.

A silence (no chord) is written '-' (minus).

Chords are given durations by specifying a time. A time can be
specified in whole beats and in fractions of a beat, where fractions
are given in 120ths and preceded by a backquote (`). For example,
`60 is half a beat, 1 is one beat, 1`60 (or `180) is a beat and a
half.

If a time is given, it is taken to indicate the duration of the
following chords, until another duration appears. For example, in the
sequence 4 A `60 C D, the A chord lasts 4 beats, and the C and D
chords half a beat each.

A pattern is selected by writing p<n> where <n> is the number given
in the definition of the pattern (see below). This affects all
following chords until another pattern is selected. Note that in
general a pattern will not `restart' when the chord changes. To ensure
that a pattern does restart at a particular point, use another pattern
specifier p<n> at that point. For example the sequence p1 A D p3 E
plays chords A and D using pattern number 1, and switches to pattern
number 3 for the E chord.

Repeats are specified by enclosing the section to be repeated in
square brackets, for example

        [ C G7 C G7 ] {twice}

plays the section twice. Different numbers of repeats can be specified
using an integer count, written immediately after the open bracket (no
spaces), thus: [4 C G7 ] {four times}. A section will repeat forever
if you write it with an asterisk [* C G7 ]. In this case, if output
is to a file then the section plays twice. Repeats can be nested.

As BASS plays, it prints out the name of the current chord. You can
also make it print out lyrics (or any other text) by placing the text
in double quotes "this is a lyric". The lyric is printed at the same
time as the chord it follows is printed. If the slash (/) character
appears in a lyric, it is printed as a carriage return.

Barlines can be included anywhere you like, written as a vertical bar
(|). Barlines are printed as the sequence plays, and are useful for
keeping track of the beat.

==============================================
Specifying a Chord Sequence -- Advanced Topics
==============================================
(This section can be safely skipped first time through !)

BASS permits chords to be played in any octave. A chord can be
transposed a number of octaves by following the note name with a
series of octave shift characters as follows:

    '    (single quote)    -- up one octave
    "    (double quote)    -- up two octaves
    ,    (comma)        -- down one octave

These symbols may be repeated to increase the shift available.
(Normally, chords are set so that C is the C major chord with middle
C as its root. The other unshifted chords have roots above middle C.)
Thus the minor chord with a root of Gb below middle C can be written
Gb,m (or G,bm but not Gbm,).

A bass note can be specified for any chord, eg G#7/E has E in the
bass, rather than the usual G#. If none is specified, the default is
that the tonic is taken to be the bass note. If the bass note occurs
in the chord, the chord is reorganised to reflect this, so that the
bass note appears first in the list of notes (an inversion). You can
prevent inversion on any chord by using \ instead of / before the bass
note. Special chords (as defined below) can be assigned bass notes,
but they are never inverted. Bass notes can also use the octave shift
characters (" ' and ,).


Specifying new chord types
==========================

Should you need a chord that BASS doesn't know about, the \chord
command lets you replace an existing chord in the chord table. Its
syntax is
        \chord <new> <old> <definition>
where <new> is the type of the new chord, old is the type of the chord
you will replace, and definition is the sequence of notes in the
chord. Both <new> and <old> require the tonic to be specified (and
they must be the same), so the chord can be defined in whichever key
you find most convenient. The chord names s1, s2, s3 have been left
blank specifically so that you can redefine them. The notes themselves
are either note names or integers representing displacement in
semitones from the tonic. For example, to define a sus4 chord (in
place of s1), you could type

    \chord Csus4 Cs1 [C F G]
or   \chord Csus4 Cs1 [0 5 7]

If you don't like my definition of an existing chord name, just
redefine it using the same name for <new> and <old>, with your new
definition. \chord definitions must come before the new names are used
in a \pat or \seq section. Use "bass -c" to see the list of chords.

As well as defining new chords using the \chord command, you can
define once only special chords without giving them names. A special
chord consists of a tonic name, and a list of notes in square
brackets. (You can also specify the notes as displacements from the
tonic in semitones). Thus C[C E G] (or C[0 4 7]) is a normal C major
chord, D[D G A C' E'] (or D[0 5 7 10 14]) would be D7 with a 4th
instead of a 3rd. Special chords do not automatically contain the
tonic (but t is still set to the tonic in the \pat section, see
below). If you find you use the same special chord type several times,
give it a name and declare it using \chord.



===================
Specifying Patterns
===================

If you are new to bass, you will probably want to try out some chord
sequences using just the standard patterns in the distributed BASS.RC
file. This section is of use only when you decide to build your own
patterns.

A pattern is defined by specifying which notes to play when, for how
long, and at what volume. Notes are always specified relative to the
current chord, and may be played on the bass channel or on the chord
channel.

The labels a b c d e f g refer to the 1st, 2nd,.. 7th note of the
chord which is playing. Label t is the tonic or the `name' of the
chord. These notes are played on the chords channel. If the chord has
fewer notes than required, higher notes are obtained by transposing
lower notes by octaves. Thus, in a three note chord, `d' is exactly
one octave higher than `a', and `e' is an octave above `b'. In a four
note chord, `d' is the fourth note of the chord, and `e' is an octave
above `a'. If the current chord has no special bass note, then `a' is
the same as `t'.

The label `x' refers to the bass note, and is played on the bass
channel. It is the same note as `t' (tonic), unless the chord has a
special bass note. If the chord has been inverted then `a' is the same
note as `x'. Normally, the bass note sounds an octave lower than the
tonic. Any of t, a, ... h can be forced on to the bass line by
prefixing with x, as in xa, xt etc.

Notes can be transposed by whole octaves using the octave shift
characters (' " ,) as described in the \seq (advanced) section. For
example, a' is an octave above a.

Other notes can be obtained by adding or subtracting a displacement
in semitones, as in x+7 (a fifth above the bass note), t-3 (minor
third below the tonic), x'+7 or x+19 (an octave plus a fifth above the
bass note).

Times are specified in beats and `120ths as in the sequence section
(`basics'). A time on its own defines the duration of the following
notes. The default is 1 beat.

A time following an @ defines the start time of the following notes.
Start times can be negative, to allow an up-beat. This can be
confusing, as it overlaps the previous pattern. Start times do not
have to be input in increasing order, they will be sorted later on.
Notes extending past the end of the current chord are not cut short,
so they might interfere with the next chord. If this happens, define
a special pattern with shorter notes.

The letter v followed by a number defines the percent volume (actually
percent midi velocity) at which the following notes sound. Volume
defaults to 100 percent at the start of each pattern cycle, giving the
midi velocity defined in the \setbass and \setchords sections. a
velocity of 0 percent is silence.

A circumflex (^) followed by a letter indicates a percussion hit.
Percussion instruments are defined using the \setperc command
described earlier. Thus ^b might indicate a thump on the bass drum.
Percussion instruments are affected by the current start time and
volume settings, but do not have a duration.

For example, the following defines pattern number 37 to be an oom-
cha-cha rhythm.

    \pat 37 3 { oom cha cha, pattern cycles every 3 beats }
        v100 @0 2 x ^b { play the bass note for two beats at start,
                      with full volume, and thump the bass drum }
        v95 @1 1 a b { play tonic and third on 2nd beat }
        @2 a b c a' ^s { huge chord + snare on third beat }

Note that if the input were a 7 chord, the 7th would never be played
by this pattern (normally the 7th is in label 'd'). It is a good idea
to keep frequently used patterns in the BASS.RC file, with descrip-
tions(!).

Patterns can contain conditional sections which are only played on
certain types of chord, and random conditionals to add variety to a
single pattern. The basic structure of a conditional is one of the
following, where `c' represents a condition, and `p' a pattern
definition.

<  (c1) p1  >        do p1 only if c1 is true.
<  (c1) p1 ~ p2 >    do p1 if c1 is true, otherwise p2.
<  (c1) p1 ~ (c2) p2 >    do p1 if c1 is true, otherwise do p2 if c2
                         is true, otherwise do nothing.
<  (c1) p1 ~ (c2) p2 ~ (c3) p3 ~ .... >
                    you should have the idea by now.

The p sections can contain any of the things that can occur in a
pattern definition, including nested conditionals.

Conditionals consist of one or more of clauses, separated by a
vertical bar (|). The clauses are tested in order, and if any are
true, the condition succeeds.

Clauses are built out of the following sorts of test.

  z    z tests for a certain type of chord. So z6b9 matches any 6b9
     chord, z (followed by a space) matches a normal major chord etc.
     z[] will match any special chord.

  #    # tests match chords with particular numbers of notes. #>3
     matches a chord with more than 3 notes, #<3 with fewer than 3
     notes, #=3 (or just #3) with exactly 3 notes.

  p    p followed by an integer is a probability test. p50 succeeds with
     a probability of 50% (that is, one half). There can be only one
     p test in a single clause.

If there is more than one test of a single type, the test succeeds if
any of them match. If there are tests of different types, the clause
succeeds if at least one of each type succeeds.

For example, the clause  p50z[]#>4#=1 succeeds on any special chord
with more than 4 or exactly 1 note, with probability one half.

=======
Example
=======

As an example of a simple pattern, here is a verison of St. Louis
Blues:
    {*St. Louis Blues in F major, 4/4}
    \pat 0 2 { bass+swing quavers }
        1 @0 x a b c d
        `60 @1 a b c d
        `30 @1`90 a b c d
    \pat 1 1 { single crash, cut short }
        1 @0 x a b c d
    \tempo 100
    \seq [* {repeat forever}
     "section A/" p0 4 F B-7 F F7 B-7 / F / C7 / F 120 p1 F C7 F C7
     "section B/" p0 4 Fm / C7 / / / Fm / / / C7 / / / 2 Fm G7 C7 /
     "section C/" p0 4 F / / F7 B-7 / F / C7 / 240 F C7 1 p1 F - -
     ]


Future Ideas:
=============
    @) Other sorts of sync -- probably midi-sync
    @) More run-time control
    @) More looping constructs
    @) leadin
    @) better screen output
    @) more pattern programming features, nicer syntax
    @) more standard patterns
    @) recoding critical sections in assembler
    ...
    (If you have some more ideas, I should be pleased to hear from
     you, but don't expect miracles because BASS is a spare time
     activity)

Bugs:
=====
    @) Sometimes notes are left sounding on exit.
    @) Identical overlapping notes lead to anomolies.
    @) Swingtime is a hack
    @) On slower computers, BASS may freeze up if too much data is
     being processed at once. The problem can be alleviated by setting
     the swing percentage to exactly 50%, although of course you lose
     the swing effect. I may solve the problem in the future by
     recoding some of the critical parts in assembler, but don't hold
     your breath.

Changes since Version 1.0:
==========================
    @) rewritten, improved parser, better error detection
    @) conditional & randomised pattern constructs
    @) support for lyrics, cues and chord name printout
    @) user definable chords
    @) chord table display
    @) removed pattern visualiser (no longer appropriate for the more
     complex pattern structure)
    @) mechanism for forcing any note onto the bass line
since V2.0:
    @) fixed chord name bug for chords with bass notes
    @) enharmonic notes distinguished
    @) added instant swing feel
    @) velocity control
    @) added humaniser
    @) ctrl-break and dos fatal error handlers
    @) midi file support added
    @) percussion added
    @) daft IRQ restriction removed
====================================================================